RegExp

Es gibt zwei Möglichkeiten, ein RegExp-Objekt zu erstellen: eine Literalnotation und einen Konstruktor.

• Die Literalnotation nimmt ein Muster zwischen zwei Schrägstrichen, gefolgt von optionalen Flags nach dem zweiten Schrägstrich.
• Die Konstruktorfunktion nimmt entweder eine Zeichenkette oder ein RegExp-Objekt als ersten Parameter und eine Zeichenkette von optionalen Flags als zweiten Parameter.

Die folgenden drei Ausdrücke erstellen dasselbe RegExp-Objekt:

const re = /ab+c/i; // literal notation
// OR
const re = new RegExp("ab+c", "i"); // constructor with string pattern as first argument
// OR
const re = new RegExp(/ab+c/, "i"); // constructor with regular expression literal as first argument

Bevor reguläre Ausdrücke verwendet werden können, müssen sie kompiliert werden. Dieser Prozess ermöglicht es ihnen, Übereinstimmungen effizienter durchzuführen. Mehr über den Prozess erfahren Sie in den dotnet-Dokumenten.

Die Literalnotation führt zur Kompilierung des regulären Ausdrucks, wenn der Ausdruck ausgewertet wird. Andererseits führt der Konstruktor des RegExp-Objekts, new RegExp('ab+c'), zur Laufzeitkompilierung des regulären Ausdrucks.

Verwenden Sie eine Zeichenkette als erstes Argument für den RegExp()-Konstruktor, wenn Sie den regulären Ausdruck aus dynamischem Input erstellen möchten.

Der Ausdruck new RegExp(/ab+c/, flags) erstellt ein neues RegExp, das die Quelle des ersten Parameters und die durch den zweiten angegebenen Flags verwendet.

Bei Verwendung der Konstruktorfunktion sind die normalen Escape-Regeln für Zeichenketten (Sonderzeichen mit \ maskieren, wenn sie in einer Zeichenkette enthalten sind) erforderlich.

Zum Beispiel sind die folgenden gleichwertig:

const re = /\w+/;
// OR
const re = new RegExp("\\w+");

Einige eingebaute Methoden behandeln regexe speziell. Sie entscheiden, ob x ein regex ist, durch mehrere Schritte:

1. x muss ein Objekt sein (kein Primitive).
2. Wenn x[Symbol.match] nicht undefined ist, prüfen Sie, ob es wahr ist.
3. Andernfalls, wenn x[Symbol.match] undefined ist, prüfen Sie, ob x mit dem RegExp-Konstruktor erstellt wurde. (Dieser Schritt sollte selten vorkommen, da wenn x ein RegExp-Objekt ist, das nicht manipuliert wurde, sollte es eine Symbol.match-Eigenschaft haben.)

Beachten Sie, dass in den meisten Fällen die Überprüfung von Symbol.match stattfinden würde, was bedeutet:

• Ein tatsächliches RegExp-Objekt, dessen Symbol.match-Eigenschaftswert falsch ist, aber nicht undefined (sogar mit allem anderen intakt, wie exec und [Symbol.replace]()) kann so verwendet werden, als ob es kein regex wäre.
• Ein Nicht-RegExp-Objekt mit einer Symbol.match-Eigenschaft wird so behandelt, als ob es ein regex wäre.

Diese Entscheidung wurde getroffen, weil [Symbol.match]() die indikativste Eigenschaft ist, dass etwas zum Abgleichen von Werten vorgesehen ist. (exec könnte auch verwendet werden, aber da es keine Symboleigenschaft ist, gäbe es zu viele Fehlermeldungen.) Zu den Orten, die regexe speziell behandeln, gehören:

• String.prototype.endsWith(), startsWith(), und includes() werfen ein TypeError, wenn das erste Argument ein regex ist.
• String.prototype.matchAll() und replaceAll() überprüfen, ob das globale Flag gesetzt ist, wenn das erste Argument ein regex ist, bevor die Methode [Symbol.matchAll]() oder [Symbol.replace]() aufgerufen wird.
• Der RegExp()-Konstruktor gibt das pattern-Argument direkt zurück, nur wenn pattern ein regex ist (unter einigen anderen Bedingungen). Wenn pattern ein regex ist, überprüft es auch die Eigenschaften source und flags von pattern, anstatt pattern zu einer Zeichenkette zu zwingen.

Zum Beispiel wird String.prototype.endsWith() alle Eingaben in Zeichenketten umwandeln, aber es wird eine Ausnahme werfen, wenn das Argument ein regex ist, weil es nur darauf ausgelegt ist, Zeichenketten abzugleichen, und die Verwendung eines regex wahrscheinlich ein Entwicklerfehler ist.

"foobar".endsWith({ toString: () => "bar" }); // true
"foobar".endsWith(/bar/); // TypeError: First argument to String.prototype.endsWith must not be a regular expression

Sie können die Überprüfung umgehen, indem Sie [Symbol.match] auf einen falschen Wert setzen, der nicht undefined ist. Dies bedeutet, dass das regex nicht für String.prototype.match() verwendet werden kann (da ohne [Symbol.match], match() ein neues RegExp-Objekt mit den zwei von re.toString() hinzugefügten Schrägstrichen erstellen würde), aber es kann für nahezu alles andere verwendet werden.

const re = /bar/g;
re[Symbol.match] = false;
"/bar/g".endsWith(re); // true
re.exec("bar"); // [ 'bar', index: 0, input: 'bar', groups: undefined ]
"bar & bar".replace(re, "foo"); // 'foo & foo'

Beachten Sie, dass mehrere der RegExp-Eigenschaften sowohl lange als auch kurze (Perl-ähnliche) Namen haben. Beide Namen beziehen sich immer auf denselben Wert. (Perl ist die Programmiersprache, von der JavaScript seine regulären Ausdrücke modelliert hat.) Siehe auch veraltete RegExp-Eigenschaften.

RegExp()

Erstellt ein neues RegExp-Objekt.

RegExp.$1, …, RegExp.$9 Veraltet

Statische schreibgeschützte Eigenschaften, die übereinstimmende untergeordnete Zeichenfolgen in Klammern enthalten.

RegExp.input ($_) Veraltet

Eine statische Eigenschaft, die die letzte Zeichenkette enthält, gegen die ein regulärer Ausdruck erfolgreich abgeglichen wurde.

RegExp.lastMatch ($&) Veraltet

Eine statische schreibgeschützte Eigenschaft, die die zuletzt abgeglichene Teilzeichenfolge enthält.

RegExp.lastParen ($+) Veraltet

Eine statische schreibgeschützte Eigenschaft, die den zuletzt abgeglichenen Teilstring in Klammern enthält.

RegExp.leftContext ($`) Veraltet

Eine statische schreibgeschützte Eigenschaft, die die Teilzeichenfolge enthält, die der letzten Übereinstimmung vorausgeht.

RegExp.rightContext ($') Veraltet

Eine statische schreibgeschützte Eigenschaft, die die Teilzeichenfolge enthält, die der letzten Übereinstimmung folgt.

RegExp[Symbol.species]

Die Konstruktorfunktion, die verwendet wird, um abgeleitete Objekte zu erstellen.

RegExp.escape()

Maskiert alle potenziellen Regex-Syntaxzeichen in einer Zeichenkette und gibt eine neue Zeichenkette zurück, die als Literal-Muster für den RegExp()-Konstruktor sicher verwendet werden kann.

Diese Eigenschaften sind auf RegExp.prototype definiert und werden von allen RegExp-Instanzen geteilt.

RegExp.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für RegExp-Instanzen ist der Anfangswert der RegExp-Konstruktor.

RegExp.prototype.dotAll

Ob . Zeilenumbrüche erfasst oder nicht.

RegExp.prototype.flags

Eine Zeichenkette, die die Flags des RegExp-Objekts enthält.

RegExp.prototype.global

Ob der reguläre Ausdruck auf alle möglichen Übereinstimmungen in einer Zeichenkette getestet wird oder nur auf die erste.

RegExp.prototype.hasIndices

Ob das Ergebnis des regulären Ausdrucks die Start- und Endindizes der erfassten Teilzeichenfolgen offenlegt.

RegExp.prototype.ignoreCase

Ob Groß- und Kleinschreibung beim Versuch, eine Übereinstimmung in einer Zeichenkette zu finden, ignoriert wird.

RegExp.prototype.multiline

Ob in Zeichenketten über mehrere Zeilen hinweg gesucht wird oder nicht.

RegExp.prototype.source

Der Text des Musters.

RegExp.prototype.sticky

Ob die Suche sticky ist oder nicht.

RegExp.prototype.unicode

Ob Unicode-Funktionen aktiviert sind oder nicht.

RegExp.prototype.unicodeSets

Ob das v Flag, ein Upgrade des u-Modus, aktiviert ist oder nicht.

Diese Eigenschaften sind eigene Eigenschaften jeder RegExp-Instanz.

lastIndex

Der Index, bei dem die nächste Übereinstimmung begonnen werden soll.

RegExp.prototype.compile() Veraltet

(Re-)kompiliert einen regulären Ausdruck während der Ausführung eines Skripts.

RegExp.prototype.exec()

Führt eine Suche nach einer Übereinstimmung in ihrem Zeichenkettenparameter durch.

RegExp.prototype.test()

Testet auf eine Übereinstimmung in ihrem Zeichenkettenparameter.

RegExp.prototype.toString()

Gibt eine Zeichenkette zurück, die das spezifizierte Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

RegExp.prototype[Symbol.match]()

Führt Übereinstimmung mit einer gegebenen Zeichenkette durch und gibt das Übereinstimmungsergebnis zurück.

RegExp.prototype[Symbol.matchAll]()

Gibt alle Übereinstimmungen des regulären Ausdrucks gegen eine Zeichenkette zurück.

RegExp.prototype[Symbol.replace]()

Ersetzt Übereinstimmungen in einer gegebenen Zeichenkette durch eine neue Teilzeichenfolge.

RegExp.prototype[Symbol.search]()

Sucht die Übereinstimmung in einer gegebenen Zeichenkette und gibt den Index des Musters in der Zeichenkette zurück.

RegExp.prototype[Symbol.split]()

Teilt eine gegebene Zeichenkette in ein Array, indem die Zeichenkette in Teilzeichenfolgen aufgeteilt wird.

Das folgende Skript verwendet die Methode String.prototype.replace(), um einen Namen im Format Vorname Nachname zu finden und ihn im Format Nachname, Vorname auszugeben.

Im Ersetzungstext verwendet das Skript $1 und $2, um die Ergebnisse der entsprechenden übereinstimmenden Klammern im regulären Ausdrucksmuster anzugeben.

const re = /(\w+)\s(\w+)/;
const str = "Maria Cruz";
const newStr = str.replace(re, "$2, $1");
console.log(newStr);

Dies zeigt "Cruz, Maria" an.

Das Standardzeilenende variiert je nach Plattform (Unix, Windows usw.). Das in diesem Beispiel bereitgestellte Aufteilen von Zeilen funktioniert auf allen Plattformen.

const text = "Some text\nAnd some more\r\nAnd yet\nThis is the end";
const lines = text.split(/\r?\n/);
console.log(lines); // [ 'Some text', 'And some more', 'And yet', 'This is the end' ]

Beachten Sie, dass die Reihenfolge der Muster im regulären Ausdruck wichtig ist.

Standardmäßig stimmt das Zeichen . nicht mit Zeilenumbrüchen überein. Um es mit Zeilenumbrüchen übereinstimmen zu lassen, verwenden Sie das s-Flag (dotAll-Modus).

const s = "Please yes\nmake my day!";

s.match(/yes.*day/);
// Returns null

s.match(/yes.*day/s);
// Returns ["yes\nmake my day"]

Das sticky-Flag zeigt an, dass der reguläre Ausdruck eine sticky Übereinstimmung in der Zielzeichenkette durchführt, indem versucht wird, an RegExp.prototype.lastIndex zu beginnen.

const str = "#foo#";
const regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex is taken into account with sticky flag)
regex.lastIndex; // 0 (reset after match failure)

Mit dem Sticky-Flag y muss die nächste Übereinstimmung an der lastIndex-Position erfolgen, während mit dem globalen Flag g die Übereinstimmung an der lastIndex-Position oder später erfolgen kann:

const re = /\d/y;
let r;
while ((r = re.exec("123 456"))) {
  console.log(r, "AND re.lastIndex", re.lastIndex);
}

// [ '1', index: 0, input: '123 456', groups: undefined ] AND re.lastIndex 1
// [ '2', index: 1, input: '123 456', groups: undefined ] AND re.lastIndex 2
// [ '3', index: 2, input: '123 456', groups: undefined ] AND re.lastIndex 3
//  … and no more match.

Mit dem globalen Flag g würden alle 6 Ziffern erfasst, nicht nur 3.

\w und \W erfassen nur auf ASCII basierte Zeichen; zum Beispiel a bis z, A bis Z, 0 bis 9, und _.

Um Zeichen aus anderen Sprachen wie Kyrillisch oder Hebräisch zu erfassen, verwenden Sie \uHHHH, wobei HHHH der Unicode-Wert des Zeichens im Hexadezimalformat ist.

Dieses Beispiel zeigt, wie man Unicode-Zeichen von einem Wort trennen kann.

const text = "Образец text на русском языке";
const regex = /[\u0400-\u04ff]+/g;

const match = regex.exec(text);
console.log(match[0]); // 'Образец'
console.log(regex.lastIndex); // 7

const match2 = regex.exec(text);
console.log(match2[0]); // 'на' (did not log 'text')
console.log(regex.lastIndex); // 15

// and so on

Das Merkmal Unicode-Eigenschafts-Beschreibungen bietet eine einfachere Möglichkeit, bestimmte Unicode-Bereiche zu Ziel, indem Erklärungen wie \p{scx=Cyrl} (um ein beliebiges kirchliches Schriftzeichen zu erfassen) oder \p{L}/u (um ein Zeichen aus einer beliebigen Sprache zu erfassen) ermöglicht werden.

Ab Firefox 34 im Falle einer Erfassungsgruppe mit Quantoren, die ihre Übung verhindern, ist der übereinstimmende Text für eine Erfassungsgruppe jetzt undefined anstelle einer leeren Zeichenkette:

// Firefox 33 or older
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${JSON.stringify(group)}`);
});
// group: ""

// Firefox 34 or newer
"x".replace(/x(.)?/g, (m, group) => {
  console.log(`group: ${group}`);
});
// group: undefined

Beachten Sie, dass RegExp.$N aufgrund der Web-Kompatibilität weiterhin eine leere Zeichenkette anstelle von undefined zurückgibt (Fehler 1053944).

• Polyfill von vielen modernen RegExp-Funktionen (dotAll, sticky Flags, benannte Erfassungsgruppen usw.) in core-js
• Reguläre Ausdrücke Leitfaden
• Reguläre Ausdrücke
• String.prototype.match()
• String.prototype.replace()
• String.prototype.split()